home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 3 / Amiga Tools 3.iso / grafik / raytracing / rayshade-4.0.6.3 / libray / libcommon / expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-09  |  6.0 KB  |  302 lines
  1. /*
  2.  * expr.c
  3.  *
  4.  * Copyright (C) 1989, 1991, Craig E. Kolb, Rod G. Bogart
  5.  * All rights reserved.
  6.  *
  7.  * This software may be freely copied, modified, and redistributed
  8.  * provided that this copyright notice is preserved on all copies.
  9.  *
  10.  * You may not distribute this software, in whole or in part, as part of
  11.  * any commercial product without the express consent of the authors.
  12.  * 
  13.  * There is no warranty or other guarantee of fitness of this software
  14.  * for any purpose.  It is provided solely "as is".
  15.  *
  16.  * expr.c,v 4.1 1994/08/09 07:54:48 explorer Exp
  17.  *
  18.  * expr.c,v
  19.  * Revision 4.1  1994/08/09  07:54:48  explorer
  20.  * Bump version to 4.1
  21.  *
  22.  * Revision 1.1.1.1  1994/08/08  04:52:01  explorer
  23.  * Initial import.  This is a prerelease of 4.0.6enh3, or 4.1 possibly.
  24.  *
  25.  * Revision 4.0  91/07/17  14:30:36  kolb
  26.  * Initial version.
  27.  * 
  28.  */
  29. #include "common.h"
  30.  
  31. Expr *TimeExpr, *FrameExpr;
  32.  
  33. static Expr *ExprCreate();
  34. void ExprFree();
  35.  
  36. Expr *
  37. ExprFloatCreate(val, timevary)
  38. Float val;
  39. int timevary;
  40. {
  41.     Expr *res;
  42.  
  43.     res = ExprCreate(FLOAT_EXPR, timevary);
  44.     res->value = val;
  45.     return res;
  46. }
  47.  
  48. Expr *
  49. ExprReuseFloatCreate(val)
  50. Float val;
  51. {
  52.     Expr *res;
  53.  
  54.     /* this should get the expr from a magic list
  55.      * that will reuse the exprs.
  56.      * But not yet...
  57.      */
  58.     res = ExprCreate(FLOAT_EXPR, FALSE);
  59.     res->value = val;
  60.     return res;
  61. }
  62.  
  63. Expr *
  64. ExprMalloc()
  65. {
  66.     return (Expr *)Malloc(sizeof(Expr));
  67. }
  68.  
  69. static
  70. Expr *
  71. ExprCreate(type, timevary)
  72. int type, timevary;
  73. {
  74.     Expr *res;
  75.  
  76.     res = ExprMalloc();
  77.     res->type = type;
  78.     res->timevary = timevary;
  79.     res->symtab = FALSE;
  80.     res->nparams = 0;
  81.     res->params = (Expr **)NULL;
  82.     res->function = (Float (*)())NULL;
  83.     res->value = 0.0;
  84.     res->timenow = -FAR_AWAY;
  85.     return res;    
  86. }
  87.  
  88. Float
  89. ExprEval(expr)
  90. Expr *expr;    /* Expression to evaluate */
  91. {
  92.     /*
  93.      * If the expression is a time-varying function,
  94.      * and its time is incorrect, evaluate at
  95.      * the current time.
  96.      */
  97.     if (expr->timevary && expr->nparams && 
  98.         !equal(TimeExpr->value, expr->timenow)) {
  99.         if (expr->nparams == 1) {
  100.             expr->value = (*expr->function)
  101.                 (ExprEval(expr->params[0]));
  102.         } else if (expr->nparams == 2) {
  103.             expr->value = (*expr->function)
  104.                 (ExprEval(expr->params[0]),
  105.                  ExprEval(expr->params[1]));
  106.         } else if (expr->nparams == 3) {
  107.             expr->value = (*expr->function)
  108.                 (ExprEval(expr->params[0]),
  109.                  ExprEval(expr->params[1]),
  110.                  ExprEval(expr->params[2]));
  111.         } else if (expr->nparams == 4) {
  112.             expr->value = (*expr->function)
  113.                 (ExprEval(expr->params[0]),
  114.                  ExprEval(expr->params[1]),
  115.                  ExprEval(expr->params[2]),
  116.                  ExprEval(expr->params[3]));
  117.         } else if (expr->nparams == 5) {
  118.             expr->value = (*expr->function)
  119.                 (ExprEval(expr->params[0]),
  120.                  ExprEval(expr->params[1]),
  121.                  ExprEval(expr->params[2]),
  122.                  ExprEval(expr->params[3]),
  123.                  ExprEval(expr->params[4]));
  124.         } else if (expr->nparams > 5)
  125.             RLerror(RL_PANIC, "Expression with > 5 args?\n");
  126.         expr->timenow = TimeExpr->value;
  127.     }
  128.     return expr->value;
  129. }
  130.  
  131. Expr *
  132. ExprFunctionCreate(fp, nparams, params, timevary)
  133. Float (*fp)();
  134. int nparams, timevary;
  135. Expr **params;
  136. {
  137.     Expr *res;
  138.  
  139.     res = ExprCreate(FLOAT_EXPR, timevary);
  140.     res->function = fp;
  141.     res->nparams = nparams;
  142.     res->params = params;
  143.  
  144.     return res;
  145. }
  146.  
  147. Expr *
  148. ExprResolve1(a, fp, timevary)
  149. Expr *a;
  150. Float (*fp)();
  151. int timevary;
  152. {
  153.     Expr **params, *res;
  154.  
  155.     if (!timevary && !a->timevary) {
  156.         res = ExprFloatCreate((*fp)(a->value), FALSE);
  157.         ExprFree(a);
  158.         return res;
  159.     } else {
  160.         params = (Expr **)Malloc(sizeof(Expr *));
  161.         params[0] = a;
  162.         return ExprFunctionCreate(fp, 1, params, TRUE);
  163.     }
  164. }
  165.  
  166. Expr *
  167. ExprResolve2(a, b, fp, timevary)
  168. Expr *a, *b;
  169. Float (*fp)();
  170. int timevary;
  171. {
  172.     Expr **params, *res;
  173.     if (!timevary && !a->timevary && !b->timevary) {
  174.         res = ExprFloatCreate((*fp)(a->value, b->value), FALSE);
  175.         ExprFree(a);
  176.         ExprFree(b);
  177.         return res;
  178.     } else {
  179.         params = (Expr **)Malloc(2 * sizeof(Expr *));
  180.         params[0] = a;
  181.         params[1] = b;
  182.         return ExprFunctionCreate(fp, 2, params, TRUE);
  183.     }
  184. }
  185.  
  186. Expr *
  187. ExprResolve3(a, b, c, fp, timevary)
  188. Expr *a, *b, *c;
  189. Float (*fp)();
  190. int timevary;
  191. {
  192.     Expr **params, *res;
  193.     if (!timevary && !a->timevary && !b->timevary && !c->timevary) {
  194.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value), 
  195.                       FALSE);
  196.         ExprFree(a);
  197.         ExprFree(b);
  198.         ExprFree(c);
  199.         return res;
  200.     } else {
  201.         params = (Expr **)Malloc(3 * sizeof(Expr *));
  202.         params[0] = a;
  203.         params[1] = b;
  204.         params[2] = c;
  205.         return ExprFunctionCreate(fp, 3, params, TRUE);
  206.     }
  207. }
  208.  
  209. Expr *
  210. ExprResolve4(a, b, c, d, fp, timevary)
  211. Expr *a, *b, *c, *d;
  212. Float (*fp)();
  213. int timevary;
  214. {
  215.     Expr **params, *res;
  216.     if (!timevary && !a->timevary && !b->timevary && !c->timevary &&
  217.         !d->timevary) {
  218.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value, 
  219.                         d->value), FALSE);
  220.         ExprFree(a);
  221.         ExprFree(b);
  222.         ExprFree(c);
  223.         ExprFree(d);
  224.         return res;
  225.     } else {
  226.         params = (Expr **)Malloc(4 * sizeof(Expr *));
  227.         params[0] = a;
  228.         params[1] = b;
  229.         params[2] = c;
  230.         params[3] = d;
  231.         return ExprFunctionCreate(fp, 4, params, TRUE);
  232.     }
  233. }
  234.  
  235. Expr *
  236. ExprResolve5(a, b, c, d, e, fp, timevary)
  237. Expr *a, *b, *c, *d, *e;
  238. Float (*fp)();
  239. int timevary;
  240. {
  241.     Expr **params, *res;
  242.     if (!timevary && !a->timevary && !b->timevary && !c->timevary &&
  243.         !d->timevary && !e->timevary) {
  244.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value, 
  245.                         d->value, e->value), FALSE);
  246.         ExprFree(a);
  247.         ExprFree(b);
  248.         ExprFree(c);
  249.         ExprFree(d);
  250.         ExprFree(e);
  251.         return res;
  252.     } else {
  253.         params = (Expr **)Malloc(5 * sizeof(Expr *));
  254.         params[0] = a;
  255.         params[1] = b;
  256.         params[2] = c;
  257.         params[3] = d;
  258.         params[4] = e;
  259.         return ExprFunctionCreate(fp, 5, params, TRUE);
  260.     }
  261. }
  262.  
  263. ExprAssoc *
  264. AssocCreate(lhs, expr, next)
  265. Float *lhs;
  266. Expr *expr;
  267. ExprAssoc *next;
  268. {
  269.     ExprAssoc *new;
  270.  
  271.     new = (ExprAssoc *)Malloc(sizeof(ExprAssoc));
  272.     new->lhs = lhs;
  273.     new->expr = expr;
  274.     new->next = next;
  275.     return new;
  276. }
  277.  
  278. void
  279. TimeSet(time)
  280. Float time;
  281. {
  282.     TimeExpr->value = time;
  283. }
  284.  
  285. void
  286. FrameSet(frame)
  287. Float frame;
  288. {
  289.     FrameExpr->value = frame;
  290. }
  291.  
  292. void
  293. ExprFree(expr)
  294. Expr *expr;
  295. {
  296.     if (!expr->symtab) {
  297.         if (expr->type == BUILTIN_EXPR && expr->params)
  298.             free((voidstar)expr->params);
  299.         free((voidstar)expr);
  300.     }
  301. }
  302.